/**
 * 自动刷新机制 - 用于应对内存泄露问题
 * 当页面内存使用接近限制时，自动刷新页面避免内存无限增长
 */

class AutoRefreshManager {
  constructor(options = {}) {
    // 默认配置
    this.config = {
      // 内存使用率阈值（0-1），超过此值将触发刷新
      memoryThreshold: options.memoryThreshold || 0.8,
      // 检查间隔（毫秒）
      checkInterval: options.checkInterval || 5000,
      // 是否启用自动刷新
      enabled: options.enabled !== false,
      // 是否询问用户确认刷新
      askUserConfirmation: options.askUserConfirmation !== false,
      // 是否在控制台输出日志
      enableLogging: options.enableLogging !== false,
      // 最大内存限制（MB），如果浏览器支持的话
      maxMemoryMB: options.maxMemoryMB || 100,
      // 刷新前清理函数
      beforeRefresh: options.beforeRefresh || null
    }

    this.isRefreshing = false
    this.warningShown = false
    this.checkTimer = null
    this.userConfirmed = false
    this.isShowingDialog = false

    // 初始化
    this.init()
  }

  /**
   * 初始化自动刷新管理器
   */
  init() {
    if (!this.config.enabled) {
      this.log('自动刷新功能已禁用')
      return
    }

    this.log('自动刷新管理器已启动', {
      memoryThreshold: this.config.memoryThreshold,
      checkInterval: this.config.checkInterval,
      maxMemoryMB: this.config.maxMemoryMB
    })

    this.startMonitoring()
  }

  /**
   * 开始监控内存使用情况
   */
  startMonitoring() {
    if (this.checkTimer) {
      clearInterval(this.checkTimer)
    }

    this.checkTimer = setInterval(() => {
      this.checkMemoryUsage()
    }, this.config.checkInterval)
  }

  /**
   * 停止监控
   */
  stopMonitoring() {
    if (this.checkTimer) {
      clearInterval(this.checkTimer)
      this.checkTimer = null
    }
    this.log('内存监控已停止')
  }

  /**
   * 检查内存使用情况
   */
  checkMemoryUsage() {
    try {
      // 如果正在刷新中或显示对话框中，跳过检查
      if (this.isRefreshing || this.isShowingDialog) {
        this.log('正在刷新中或显示对话框中，跳过内存检查')
        return
      }

      const memoryInfo = this.getMemoryInfo()

      if (memoryInfo) {
        this.log('内存使用情况', memoryInfo)

        // 检查是否需要刷新
        if (this.shouldRefresh(memoryInfo)) {
          this.handleMemoryWarning()
        }
      }
    } catch (error) {
      this.log('检查内存使用情况时出错:', error)
    }
  }

  /**
   * 获取内存信息
   */
  getMemoryInfo() {
    // 优先使用 performance.memory（Chrome）
    if (performance.memory) {
      const memory = performance.memory
      return {
        used: memory.usedJSHeapSize,
        total: memory.totalJSHeapSize,
        limit: memory.jsHeapSizeLimit,
        usedMB: Math.round((memory.usedJSHeapSize / 1024 / 1024) * 100) / 100,
        totalMB: Math.round((memory.totalJSHeapSize / 1024 / 1024) * 100) / 100,
        limitMB: Math.round((memory.jsHeapSizeLimit / 1024 / 1024) * 100) / 100,
        usageRatio: memory.usedJSHeapSize / memory.jsHeapSizeLimit
      }
    }

    // 如果浏览器不支持 performance.memory，使用估算方法
    return this.estimateMemoryUsage()
  }

  /**
   * 估算内存使用情况（当浏览器不支持 performance.memory 时）
   */
  estimateMemoryUsage() {
    // 基于页面元素数量和复杂度估算
    const elements = document.querySelectorAll('*').length
    const textNodes = document.querySelectorAll('*').length
    const estimatedMemory = elements * 0.1 + textNodes * 0.01 // 粗略估算

    return {
      estimated: true,
      elements: elements,
      estimatedMemoryMB: Math.round(estimatedMemory * 100) / 100,
      usageRatio: Math.min(estimatedMemory / this.config.maxMemoryMB, 1)
    }
  }

  /**
   * 判断是否需要刷新
   */
  shouldRefresh(memoryInfo) {
    if (this.isRefreshing) {
      return false
    }

    // 如果浏览器支持精确内存信息
    if (memoryInfo.usageRatio !== undefined) {
      return memoryInfo.usageRatio >= this.config.memoryThreshold
    }

    // 如果只有估算信息
    if (
      memoryInfo.estimated &&
      memoryInfo.estimatedMemoryMB >=
        this.config.maxMemoryMB * this.config.memoryThreshold
    ) {
      return true
    }

    return false
  }

  /**
   * 处理内存警告
   */
  handleMemoryWarning() {
    if (this.warningShown) {
      return
    }

    this.warningShown = true
    this.log('内存使用率过高，准备刷新页面')

    // 如果启用了用户确认，显示确认对话框
    if (this.config.askUserConfirmation) {
      this.showConfirmationDialog()
    } else {
      // 直接刷新页面
      this.refreshPage()
    }
  }

  /**
   * 显示用户确认对话框
   */
  showConfirmationDialog() {
    // 防止重复显示确认对话框
    if (this.isShowingDialog) {
      return
    }

    this.isShowingDialog = true
    this.log('显示用户确认对话框')

    // 使用系统自带的确认对话框
    const message = `⚠️ 内存使用率过高警告

检测到页面内存使用率过高，为避免内存泄露导致页面崩溃，建议立即刷新页面。

⚠️ 重要提示：
刷新页面将清除当前所有未保存的数据，请确保重要数据已保存。

是否立即刷新页面？`

    // 显示系统确认对话框
    const userConfirmed = confirm(message)

    if (userConfirmed) {
      this.userConfirmed = true
      this.log('用户确认刷新页面')
      this.refreshPage()
    } else {
      this.log('用户取消刷新，稍后重试')
      this.resetWarningState()
    }

    // 重置对话框状态
    this.isShowingDialog = false
  }

  /**
   * 重置警告状态
   */
  resetWarningState() {
    // 延迟重置，避免立即重新触发
    setTimeout(() => {
      this.warningShown = false
      this.userConfirmed = false
      this.log('警告状态已重置，将在下次检查时重新评估')
    }, 10000) // 10秒后重置状态，给内存足够时间释放
  }

  /**
   * 刷新页面
   */
  refreshPage() {
    if (this.isRefreshing) {
      return
    }

    this.isRefreshing = true
    this.log('开始刷新页面')

    // 执行清理函数
    if (typeof this.config.beforeRefresh === 'function') {
      try {
        this.config.beforeRefresh()
      } catch (error) {
        this.log('执行清理函数时出错:', error)
      }
    }

    // 停止监控
    this.stopMonitoring()

    // 刷新页面
    setTimeout(() => {
      window.location.reload()
    }, 100)
  }

  /**
   * 手动刷新页面
   */
  forceRefresh() {
    this.log('手动触发页面刷新')
    this.refreshPage()
  }

  /**
   * 更新配置
   */
  updateConfig(newConfig) {
    this.config = { ...this.config, ...newConfig }
    this.log('配置已更新', this.config)

    // 如果启用了监控，重新启动
    if (this.config.enabled && !this.checkTimer) {
      this.startMonitoring()
    } else if (!this.config.enabled && this.checkTimer) {
      this.stopMonitoring()
    }
  }

  /**
   * 获取当前状态
   */
  getStatus() {
    return {
      enabled: this.config.enabled,
      isMonitoring: !!this.checkTimer,
      isRefreshing: this.isRefreshing,
      warningShown: this.warningShown,
      memoryInfo: this.getMemoryInfo()
    }
  }

  /**
   * 日志输出
   */
  log(message, data = null) {
    if (!this.config.enableLogging) {
      return
    }

    const timestamp = new Date().toLocaleTimeString()
    const logMessage = `[AutoRefresh ${timestamp}] ${message}`

    if (data) {
      console.log(logMessage, data)
    } else {
      console.log(logMessage)
    }
  }

  /**
   * 销毁管理器
   */
  destroy() {
    this.stopMonitoring()
    this.log('自动刷新管理器已销毁')
  }
}

// 创建全局实例
window.autoRefreshManager = new AutoRefreshManager({
  memoryThreshold: 0.7, // 内存使用率达到80%时刷新
  checkInterval: 2000, // 每5秒检查一次
  maxMemoryMB: 100, // 最大内存限制100MB
  askUserConfirmation: false, // 询问用户确认
  enableLogging: false // 启用日志
})

// 导出类供其他模块使用
if (typeof module !== 'undefined' && module.exports) {
  module.exports = AutoRefreshManager
}

// 在页面卸载时清理
window.addEventListener('beforeunload', () => {
  if (window.autoRefreshManager) {
    window.autoRefreshManager.destroy()
  }
})

// 提供全局API
window.AutoRefresh = {
  // 手动刷新
  refresh: () => window.autoRefreshManager.forceRefresh(),

  // 获取状态
  getStatus: () => window.autoRefreshManager.getStatus(),

  // 更新配置
  updateConfig: config => window.autoRefreshManager.updateConfig(config),

  // 启用/禁用
  enable: () => window.autoRefreshManager.updateConfig({ enabled: true }),
  disable: () => window.autoRefreshManager.updateConfig({ enabled: false }),

  // 停止监控
  stop: () => window.autoRefreshManager.stopMonitoring(),

  // 开始监控
  start: () => window.autoRefreshManager.startMonitoring()
}
